package com.hlt.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hlt.dto.SearchPageQueryDTO;
import com.hlt.entity.Categories;
import com.hlt.entity.Posts;
import com.hlt.entity.Users;
import com.hlt.mapper.CategoriesMapper;
import com.hlt.mapper.PostsMapper;
import com.hlt.mapper.UsersMapper;
import com.hlt.service.HomeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class HomeServiceImpl implements HomeService {

    @Autowired
    private PostsMapper postsMapper;
    @Autowired
    private CategoriesMapper  categoriesMapper;
    @Autowired
    private UsersMapper usersMapper;

    @Override
    public List<Posts> getHotArticles() {
        // 构建分页对象，获取前 10 条记录
        Page<Posts> page = new Page<>(1, 10);

        // 构建查询条件，只查询已发布的文章（假设状态 1 表示已发布）
        QueryWrapper<Posts> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)// 添加排序条件，按 (点赞数 + 评论数 + 浏览数) 降序排序
                    .orderByDesc("(likes_count + comments_count + views_count)");

        // 执行查询
        Page<Posts> postsPage = postsMapper.selectPage(page, queryWrapper);

        // 返回查询结果
        return postsPage.getRecords();
    }
    /**
     * 获取最新文章列表（按创建时间倒序）
     *
     * @return 最新文章列表
     */
    @Override
    public List<Posts> getLatestArticles() {
        // 构建分页对象，获取第一页，每页10条数据（与热门文章分页逻辑保持一致）
        Page<Posts> page = new Page<>(1,10);

        // 构建查询条件：筛选已发布的文章（status=1），并按创建时间倒序排列
        QueryWrapper<Posts> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)          // 过滤已发布状态（与热门文章条件一致）
                    .orderByDesc("created_at");  // 按创建时间倒序排序（最新的在前）

        // 执行分页查询
        Page<Posts> postsPage = postsMapper.selectPage(page, queryWrapper);

        // 返回分页结果中的记录列表
        return postsPage.getRecords();
    }



    /**
     * 获取推荐文章列表（按最后更新时间倒序）
     */
    @Override
    public List<Posts> getRecommendedArticles() {
        Page<Posts> page = new Page<>(1,10);
        QueryWrapper<Posts> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)          // 过滤已发布状态
                    .orderByDesc("updated_at"); // 按最后更新时间倒序（推荐近期更新的文章）
        Page<Posts> postsPage = postsMapper.selectPage(page, queryWrapper);
        return postsPage.getRecords();
    }

    /**
     * 获取热门标签列表（按分类下文章数量降序）
     */
    @Override
    public List<Categories> getHotTags() {
        QueryWrapper<Categories> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)       // 过滤正常状态的分类
                    .orderByDesc("count"); // 按分类下文章数量（count字段）降序排列
        return categoriesMapper.selectList(queryWrapper);
    }

    /**
     * 获取热门作者列表（按作者文章总热度降序）
     */
    @Override
    public List<Users> getHotAuthors() {
        // 1. 统计每个作者的总热度（所有文章的likes_count + comments_count + views_count之和）
        QueryWrapper<Posts> postQuery = new QueryWrapper<>();
        postQuery.select("user_id, SUM(likes_count + comments_count + views_count) as total_heat")
                 .groupBy("user_id")
                 .orderByDesc("total_heat")
                 .last("LIMIT 10"); // 取总热度前10的作者

        List<Map<String, Object>> authorHeatList = postsMapper.selectMaps(postQuery);

        // 2. 提取作者ID并查询用户信息
        if (authorHeatList.isEmpty()) {
            return List.of();
        }
        List<Long> userIds = authorHeatList.stream()
                .map(map -> Long.parseLong(map.get("user_id").toString()))
                .collect(Collectors.toList());

        QueryWrapper<Users> userQuery = new QueryWrapper<>();
        userQuery.in("user_id", userIds);
        return usersMapper.selectList(userQuery);
    }

    /**
     * 获取分类列表（正常状态，按创建时间升序）
     */
    @Override
    public List<Categories> getCategories() {
        QueryWrapper<Categories> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)        // 过滤正常状态的分类
                    .orderByAsc("created_at"); // 按创建时间升序排列（保持分类顺序）
        return categoriesMapper.selectList(queryWrapper);
    }

    /**
     * 搜索文章（标题或内容包含关键词，按创建时间倒序）
     */
    @Override
    public List<Posts> searchArticles(SearchPageQueryDTO searchPageQueryDTO) {
        Page<Posts> page = new Page<>(searchPageQueryDTO.getPageNum(), searchPageQueryDTO.getPageSize());
        QueryWrapper<Posts> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("status", 1)                   // 过滤已发布状态
                    .like("title", searchPageQueryDTO.getKeyword())            // 标题包含关键词
                    .or()
                    .like("content", searchPageQueryDTO.getKeyword())          // 或内容包含关键词
                    .orderByDesc("created_at");        // 按创建时间倒序（最新结果优先）
        Page<Posts> postsPage = postsMapper.selectPage(page, queryWrapper);
        return postsPage.getRecords();
    }
}